package com.game.sdk.ui;



import android.content.Context;


import android.support.v4.view.ViewPager;

/**
 * Layout manager that allows the user to flip horizontally or vertically
 * through pages of data. You supply an implementation of a {@link PagerAdapter}
 * to generate the pages that the view shows.
 * 
 * <p>
 * Note this class is currently under early design and development. The API will
 * likely change in later updates of the compatibility library, requiring
 * changes to the source code of apps when they are compiled against the newer
 * version.
 * </p>
 */
public class DirectionalViewPager extends ViewPager {
//	private static final String TAG = "DirectionalViewPager";
//	private static final String XML_NS = "http://schemas.android.com/apk/res/android";
//	private static final boolean DEBUG = false;
//
//	private static final boolean USE_CACHE = false;
//
//	public static final int HORIZONTAL = 0;
//	public static final int VERTICAL = 1;
//
//	static class ItemInfo {
//		Object object;
//		int position;
//		boolean scrolling;
//	}
//
//	private final ArrayList<ItemInfo> mItems = new ArrayList<ItemInfo>();
//
//	private PagerAdapter mAdapter;
//	private int mCurItem; // Index of currently displayed page.
//	private int mRestoredCurItem = -1;
//	private Parcelable mRestoredAdapterState = null;
//	private ClassLoader mRestoredClassLoader = null;
//	private Scroller mScroller;
//	private VerticalViewPagerCompat.DataSetObserver mObserver;
//
//	private int mChildWidthMeasureSpec;
//	private int mChildHeightMeasureSpec;
//	private boolean mInLayout;
//
//	private boolean mScrollingCacheEnabled;
//
//	private boolean mPopulatePending;
//	private boolean mScrolling;
//
//	private boolean mIsBeingDragged;
//	private boolean mIsUnableToDrag;
//	private int mTouchSlop;
//	private float mInitialMotion;
//	/**
//	 * Position of the last motion event.
//	 */
//	private float mLastMotionX;
//	private float mLastMotionY;
//	private int mOrientation = HORIZONTAL;
//	/**
//	 * ID of the active pointer. This is used to retain consistency during
//	 * drags/flings if multiple pointers are used.
//	 */
//	private int mActivePointerId = INVALID_POINTER;
//	/**
//	 * Sentinel value for no current active pointer. Used by
//	 * {@link #mActivePointerId}.
//	 */
//	private static final int INVALID_POINTER = -1;
//
//	/**
//	 * Determines speed during touch scrolling
//	 */
//	private VelocityTracker mVelocityTracker;
//	private int mMinimumVelocity;
//	private int mMaximumVelocity;
//
//	private OnPageChangeListener mOnPageChangeListener;
//
//	private int mScrollState = SCROLL_STATE_IDLE;

	public DirectionalViewPager(Context context) {
		super(context);
		//initViewPager();
	}

//	public DirectionalViewPager(Context context, AttributeSet attrs) {
//		super(context, attrs);
//		initViewPager();
//
//		// We default to horizontal, only change if a value is explicitly
//		// specified
//		int orientation = attrs.getAttributeIntValue(XML_NS, "orientation", -1);
//		if (orientation != -1) {
//			setOrientation(orientation);
//		}
//	}

//	void initViewPager() {
//		setWillNotDraw(false);
//		mScroller = new Scroller(getContext());
//		final ViewConfiguration configuration = ViewConfiguration
//				.get(getContext());
//		mTouchSlop = ViewConfigurationCompat
//				.getScaledPagingTouchSlop(configuration);
//		mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
//		mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
//	}
//
//	private void setScrollState(int newState) {
//		if (mScrollState == newState) {
//			return;
//		}
//
//		mScrollState = newState;
//		if (mOnPageChangeListener != null) {
//			mOnPageChangeListener.onPageScrollStateChanged(newState);
//		}
//	}
//
//	public void setAdapter(PagerAdapter adapter) {
//		if (mAdapter != null) {
//			VerticalViewPagerCompat.setDataSetObserver(mAdapter, null);
//		}
//
//		mAdapter = adapter;
//
//		if (mAdapter != null) {
//			if (mObserver == null) {
//				mObserver = new DataSetObserver();
//			}
//			VerticalViewPagerCompat.setDataSetObserver(mAdapter, mObserver);
//			mPopulatePending = false;
//			if (mRestoredCurItem >= 0) {
//				mAdapter.restoreState(mRestoredAdapterState,
//						mRestoredClassLoader);
//				setCurrentItemInternal(mRestoredCurItem, false, true);
//				mRestoredCurItem = -1;
//				mRestoredAdapterState = null;
//				mRestoredClassLoader = null;
//			} else {
//				populate();
//			}
//		}
//	}
//
//	public PagerAdapter getAdapter() {
//		return mAdapter;
//	}
//
//	public void setCurrentItem(int item) {
//		mPopulatePending = false;
//		setCurrentItemInternal(item, true, false);
//	}
//
//	void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
//		if (mAdapter == null || mAdapter.getCount() <= 0) {
//			setScrollingCacheEnabled(false);
//			return;
//		}
//		if (!always && mCurItem == item && mItems.size() != 0) {
//			setScrollingCacheEnabled(false);
//			return;
//		}
//		if (item < 0) {
//			item = 0;
//		} else if (item >= mAdapter.getCount()) {
//			item = mAdapter.getCount() - 1;
//		}
//		if (item > (mCurItem + 1) || item < (mCurItem - 1)) {
//			// We are doing a jump by more than one page. To avoid
//			// glitches, we want to keep all current pages in the view
//			// until the scroll ends.
//			for (int i = 0; i < mItems.size(); i++) {
//				mItems.get(i).scrolling = true;
//			}
//		}
//		final boolean dispatchSelected = mCurItem != item;
//		mCurItem = item;
//		populate();
//		if (smoothScroll) {
//			if (mOrientation == HORIZONTAL) {
//				smoothScrollTo(getWidth() * item, 0);
//			} else {
//				smoothScrollTo(0, getHeight() * item);
//			}
//			if (dispatchSelected && mOnPageChangeListener != null) {
//				mOnPageChangeListener.onPageSelected(item);
//			}
//		} else {
//			if (dispatchSelected && mOnPageChangeListener != null) {
//				mOnPageChangeListener.onPageSelected(item);
//			}
//			completeScroll();
//			if (mOrientation == HORIZONTAL) {
//				scrollTo(getWidth() * item, 0);
//			} else {
//				scrollTo(0, getHeight() * item);
//			}
//		}
//	}
//
//	public void setOnPageChangeListener(OnPageChangeListener listener) {
//		mOnPageChangeListener = listener;
//	}
//
//	/**
//	 * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
//	 * 
//	 * @param dx
//	 *            the number of pixels to scroll by on the X axis
//	 * @param dy
//	 *            the number of pixels to scroll by on the Y axis
//	 */
//	void smoothScrollTo(int x, int y) {
//		if (getChildCount() == 0) {
//			// Nothing to do.
//			setScrollingCacheEnabled(false);
//			return;
//		}
//		int sx = getScrollX();
//		int sy = getScrollY();
//		int dx = x - sx;
//		int dy = y - sy;
//		if (dx == 0 && dy == 0) {
//			completeScroll();
//			return;
//		}
//
//		setScrollingCacheEnabled(true);
//		mScrolling = true;
//		setScrollState(SCROLL_STATE_SETTLING);
//		mScroller.startScroll(sx, sy, dx, dy);
//		invalidate();
//	}
//
//	void addNewItem(int position, int index) {
//		ItemInfo ii = new ItemInfo();
//		ii.position = position;
//		ii.object = mAdapter.instantiateItem(this, position);
//		if (index < 0) {
//			mItems.add(ii);
//		} else {
//			mItems.add(index, ii);
//		}
//	}
//
//	void dataSetChanged() {
//		// This method only gets called if our observer is attached, so mAdapter
//		// is non-null.
//
//		boolean needPopulate = mItems.isEmpty() && mAdapter.getCount() > 0;
//		int newCurrItem = -1;
//
//		for (int i = 0; i < mItems.size(); i++) {
//			final ItemInfo ii = mItems.get(i);
//			final int newPos = mAdapter.getItemPosition(ii.object);
//
//			if (newPos == PagerAdapter.POSITION_UNCHANGED) {
//				continue;
//			}
//
//			if (newPos == PagerAdapter.POSITION_NONE) {
//				mItems.remove(i);
//				i--;
//				mAdapter.destroyItem(this, ii.position, ii.object);
//				needPopulate = true;
//
//				if (mCurItem == ii.position) {
//					// Keep the current item in the valid range
//					newCurrItem = Math.max(0,
//							Math.min(mCurItem, mAdapter.getCount() - 1));
//				}
//				continue;
//			}
//
//			if (ii.position != newPos) {
//				if (ii.position == mCurItem) {
//					// Our current item changed position. Follow it.
//					newCurrItem = newPos;
//				}
//
//				ii.position = newPos;
//				needPopulate = true;
//			}
//		}
//
//		if (newCurrItem >= 0) {
//			// TODO This currently causes a jump.
//			setCurrentItemInternal(newCurrItem, false, true);
//			needPopulate = true;
//		}
//		if (needPopulate) {
//			populate();
//			requestLayout();
//		}
//	}
//
//	void populate() {
//		if (mAdapter == null) {
//			return;
//		}
//
//		// Bail now if we are waiting to populate. This is to hold off
//		// on creating views from the time the user releases their finger to
//		// fling to a new position until we have finished the scroll to
//		// that position, avoiding glitches from happening at that point.
//		if (mPopulatePending) {
//			if (DEBUG)
//				Log.i(TAG, "populate is pending, skipping for now...");
//			return;
//		}
//
//		// Also, don't populate until we are attached to a window. This is to
//		// avoid trying to populate before we have restored our view hierarchy
//		// state and conflicting with what is restored.
//		if (getWindowToken() == null) {
//			return;
//		}
//
//		mAdapter.startUpdate(this);
//
//		final int startPos = mCurItem > 0 ? mCurItem - 1 : mCurItem;
//		final int count = mAdapter.getCount();
//		final int endPos = mCurItem < (count - 1) ? mCurItem + 1 : count - 1;
//
//		if (DEBUG)
//			Log.v(TAG, "populating: startPos=" + startPos + " endPos=" + endPos);
//
//		// Add and remove pages in the existing list.
//		int lastPos = -1;
//		for (int i = 0; i < mItems.size(); i++) {
//			ItemInfo ii = mItems.get(i);
//			if ((ii.position < startPos || ii.position > endPos)
//					&& !ii.scrolling) {
//				if (DEBUG)
//					Log.i(TAG, "removing: " + ii.position + " @ " + i);
//				mItems.remove(i);
//				i--;
//				mAdapter.destroyItem(this, ii.position, ii.object);
//			} else if (lastPos < endPos && ii.position > startPos) {
//				// The next item is outside of our range, but we have a gap
//				// between it and the last item where we want to have a page
//				// shown. Fill in the gap.
//				lastPos++;
//				if (lastPos < startPos) {
//					lastPos = startPos;
//				}
//				while (lastPos <= endPos && lastPos < ii.position) {
//					if (DEBUG)
//						Log.i(TAG, "inserting: " + lastPos + " @ " + i);
//					addNewItem(lastPos, i);
//					lastPos++;
//					i++;
//				}
//			}
//			lastPos = ii.position;
//		}
//
//		// Add any new pages we need at the end.
//		lastPos = mItems.size() > 0 ? mItems.get(mItems.size() - 1).position
//				: -1;
//		if (lastPos < endPos) {
//			lastPos++;
//			lastPos = lastPos > startPos ? lastPos : startPos;
//			while (lastPos <= endPos) {
//				if (DEBUG)
//					Log.i(TAG, "appending: " + lastPos);
//				addNewItem(lastPos, -1);
//				lastPos++;
//			}
//		}
//
//		if (DEBUG) {
//			Log.i(TAG, "Current page list:");
//			for (int i = 0; i < mItems.size(); i++) {
//				Log.i(TAG, "#" + i + ": page " + mItems.get(i).position);
//			}
//		}
//
//		mAdapter.finishUpdate(this);
//	}
//
//	public static class SavedState extends BaseSavedState {
//		int position;
//		Parcelable adapterState;
//		ClassLoader loader;
//
//		public SavedState(Parcelable superState) {
//			super(superState);
//		}
//
//		@Override
//		public void writeToParcel(Parcel out, int flags) {
//			super.writeToParcel(out, flags);
//			out.writeInt(position);
//			out.writeParcelable(adapterState, flags);
//		}
//
//		@Override
//		public String toString() {
//			return "FragmentPager.SavedState{"
//					+ Integer.toHexString(System.identityHashCode(this))
//					+ " position=" + position + "}";
//		}
//
//		public static final Parcelable.Creator<SavedState> CREATOR = ParcelableCompat
//				.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {
//					@Override
//					public SavedState createFromParcel(Parcel in,
//							ClassLoader loader) {
//						return new SavedState(in, loader);
//					}
//
//					@Override
//					public SavedState[] newArray(int size) {
//						return new SavedState[size];
//					}
//				});
//
//		SavedState(Parcel in, ClassLoader loader) {
//			super(in);
//			if (loader == null) {
//				loader = getClass().getClassLoader();
//			}
//			position = in.readInt();
//			adapterState = in.readParcelable(loader);
//			this.loader = loader;
//		}
//	}
//
//	@Override
//	public Parcelable onSaveInstanceState() {
//		try {
//			Parcelable superState = super.onSaveInstanceState();
//			SavedState ss = new SavedState(superState);
//			ss.position = mCurItem;
//			ss.adapterState = mAdapter.saveState();
//			return ss;
//		} catch (NullPointerException e) {
//			e.printStackTrace();
//		}
//		return null;
//	}
//
//	@Override
//	public void onRestoreInstanceState(Parcelable state) {
//		if (!(state instanceof SavedState)) {
//			super.onRestoreInstanceState(state);
//			return;
//		}
//		SavedState ss = (SavedState) state;
//		super.onRestoreInstanceState(ss.getSuperState());
//
//		if (mAdapter != null) {
//			mAdapter.restoreState(ss.adapterState, ss.loader);
//			setCurrentItemInternal(ss.position, false, true);
//		} else {
//			mRestoredCurItem = ss.position;
//			mRestoredAdapterState = ss.adapterState;
//			mRestoredClassLoader = ss.loader;
//		}
//	}
//
//	public int getOrientation() {
//		return mOrientation;
//	}
//
//	public void setOrientation(int orientation) {
//		switch (orientation) {
//		case HORIZONTAL:
//		case VERTICAL:
//			break;
//
//		default:
//			throw new IllegalArgumentException(
//					"Only HORIZONTAL and VERTICAL are valid orientations.");
//		}
//
//		if (orientation == mOrientation) {
//			return;
//		}
//
//		// Complete any scroll we are currently in the middle of
//		completeScroll();
//
//		// Reset values
//		mInitialMotion = 0;
//		mLastMotionX = 0;
//		mLastMotionY = 0;
//		if (mVelocityTracker != null) {
//			mVelocityTracker.clear();
//		}
//
//		// Adjust scroll for new orientation
//		mOrientation = orientation;
//		if (mOrientation == HORIZONTAL) {
//			scrollTo(mCurItem * getWidth(), 0);
//		} else {
//			scrollTo(0, mCurItem * getHeight());
//		}
//		requestLayout();
//	}
//
//	@Override
//	public void addView(View child, int index, ViewGroup.LayoutParams params) {
//		if (mInLayout) {
//			addViewInLayout(child, index, params);
//			child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
//		} else {
//			super.addView(child, index, params);
//		}
//
//		if (USE_CACHE) {
//			if (child.getVisibility() != GONE) {
//				child.setDrawingCacheEnabled(mScrollingCacheEnabled);
//			} else {
//				child.setDrawingCacheEnabled(false);
//			}
//		}
//	}
//
//	ItemInfo infoForChild(View child) {
//		for (int i = 0; i < mItems.size(); i++) {
//			ItemInfo ii = mItems.get(i);
//			if (mAdapter.isViewFromObject(child, ii.object)) {
//				return ii;
//			}
//		}
//		return null;
//	}
//
//	@Override
//	protected void onAttachedToWindow() {
//		super.onAttachedToWindow();
//		if (mAdapter != null) {
//			populate();
//		}
//	}
//
//	@Override
//	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//		// For simple implementation, or internal size is always 0.
//		// We depend on the container to specify the layout size of
//		// our view. We can't really know what it is since we will be
//		// adding and removing different arbitrary views and do not
//		// want the layout to change as this happens.
//		setMeasuredDimension(getDefaultSize(0, widthMeasureSpec),
//				getDefaultSize(0, heightMeasureSpec));
//
//		// Children are just made to fill our space.
//		mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth()
//				- getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY);
//		mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
//				getMeasuredHeight() - getPaddingTop() - getPaddingBottom(),
//				MeasureSpec.EXACTLY);
//
//		// Make sure we have created all fragments that we need to have shown.
//		mInLayout = true;
//		populate();
//		mInLayout = false;
//
//		// Make sure all children have been properly measured.
//		final int size = getChildCount();
//		for (int i = 0; i < size; ++i) {
//			final View child = getChildAt(i);
//			if (child.getVisibility() != GONE) {
//				if (DEBUG)
//					Log.v(TAG, "Measuring #" + i + " " + child + ": "
//							+ mChildWidthMeasureSpec + " x "
//							+ mChildHeightMeasureSpec);
//				child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
//			}
//		}
//	}
//
//	@Override
//	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
//		super.onSizeChanged(w, h, oldw, oldh);
//
//		// Make sure scroll position is set correctly.
//		if (mOrientation == HORIZONTAL) {
//			int scrollPos = mCurItem * w;
//			if (scrollPos != getScrollX()) {
//				completeScroll();
//				scrollTo(scrollPos, getScrollY());
//			}
//		} else {
//			int scrollPos = mCurItem * h;
//			if (scrollPos != getScrollY()) {
//				completeScroll();
//				scrollTo(getScrollX(), scrollPos);
//			}
//		}
//	}
//
//	@Override
//	protected void onLayout(boolean changed, int l, int t, int r, int b) {
//		mInLayout = true;
//		populate();
//		mInLayout = false;
//
//		final int count = getChildCount();
//		final int size = (mOrientation == HORIZONTAL) ? r - l : b - t;
//
//		for (int i = 0; i < count; i++) {
//			View child = getChildAt(i);
//			ItemInfo ii;
//			if (child.getVisibility() != GONE
//					&& (ii = infoForChild(child)) != null) {
//				int off = size * ii.position;
//				int childLeft = getPaddingLeft();
//				int childTop = getPaddingTop();
//				if (mOrientation == HORIZONTAL) {
//					childLeft += off;
//				} else {
//					childTop += off;
//				}
//				if (DEBUG)
//					Log.v(TAG,
//							"Positioning #" + i + " " + child + " f="
//									+ ii.object + ":" + childLeft + ","
//									+ childTop + " " + child.getMeasuredWidth()
//									+ "x" + child.getMeasuredHeight());
//				child.layout(childLeft, childTop,
//						childLeft + child.getMeasuredWidth(),
//						childTop + child.getMeasuredHeight());
//			}
//		}
//	}
//
//	@Override
//	public void computeScroll() {
//		if (DEBUG)
//			Log.i(TAG, "computeScroll: finished=" + mScroller.isFinished());
//		if (!mScroller.isFinished()) {
//			if (mScroller.computeScrollOffset()) {
//				if (DEBUG)
//					Log.i(TAG, "computeScroll: still scrolling");
//				int oldX = getScrollX();
//				int oldY = getScrollY();
//				int x = mScroller.getCurrX();
//				int y = mScroller.getCurrY();
//
//				if (oldX != x || oldY != y) {
//					scrollTo(x, y);
//				}
//
//				if (mOnPageChangeListener != null) {
//					int size;
//					int value;
//					if (mOrientation == HORIZONTAL) {
//						size = getWidth();
//						value = x;
//					} else {
//						size = getHeight();
//						value = y;
//					}
//
//					final int position = value / size;
//					final int offsetPixels = value % size;
//					final float offset = (float) offsetPixels / size;
//					mOnPageChangeListener.onPageScrolled(position, offset,
//							offsetPixels);
//				}
//
//				// Keep on drawing until the animation has finished.
//				invalidate();
//				return;
//			}
//		}
//
//		// Done with scroll, clean up state.
//		completeScroll();
//	}
//
//	private void completeScroll() {
//		boolean needPopulate;
//		if ((needPopulate = mScrolling)) {
//			// Done with scroll, no longer want to cache view drawing.
//			setScrollingCacheEnabled(false);
//			mScroller.abortAnimation();
//			int oldX = getScrollX();
//			int oldY = getScrollY();
//			int x = mScroller.getCurrX();
//			int y = mScroller.getCurrY();
//			if (oldX != x || oldY != y) {
//				scrollTo(x, y);
//			}
//			setScrollState(SCROLL_STATE_IDLE);
//		}
//		mPopulatePending = false;
//		mScrolling = false;
//		for (int i = 0; i < mItems.size(); i++) {
//			ItemInfo ii = mItems.get(i);
//			if (ii.scrolling) {
//				needPopulate = true;
//				ii.scrolling = false;
//			}
//		}
//		if (needPopulate) {
//			populate();
//		}
//	}
//
//	@Override
//	public boolean onInterceptTouchEvent(MotionEvent ev) {
//		/*
//		 * This method JUST determines whether we want to intercept the motion.
//		 * If we return true, onMotionEvent will be called and we do the actual
//		 * scrolling there.
//		 */
//
//		final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
//
//		// Always take care of the touch gesture being complete.
//		if (action == MotionEvent.ACTION_CANCEL
//				|| action == MotionEvent.ACTION_UP) {
//			// Release the drag.
//			if (DEBUG)
//				Log.v(TAG, "Intercept done!");
//			mIsBeingDragged = false;
//			mIsUnableToDrag = false;
//			mActivePointerId = INVALID_POINTER;
//			return false;
//		}
//
//		// Nothing more to do here if we have decided whether or not we
//		// are dragging.
//		if (action != MotionEvent.ACTION_DOWN) {
//			if (mIsBeingDragged) {
//				if (DEBUG)
//					Log.v(TAG, "Intercept returning true!");
//				return true;
//			}
//			if (mIsUnableToDrag) {
//				if (DEBUG)
//					Log.v(TAG, "Intercept returning false!");
//				return false;
//			}
//		}
//
//		switch (action) {
//		case MotionEvent.ACTION_MOVE: {
//			/*
//			 * mIsBeingDragged == false, otherwise the shortcut would have
//			 * caught it. Check whether the user has moved far enough from his
//			 * original down touch.
//			 */
//
//			/*
//			 * Locally do absolute value. mLastMotionY is set to the y value of
//			 * the down event.
//			 */
//			final int activePointerId = mActivePointerId;
//			if (activePointerId == INVALID_POINTER
//					&& Build.VERSION.SDK_INT > Build.VERSION_CODES.DONUT) {
//				// If we don't have a valid id, the touch down wasn't on
//				// content.
//				break;
//			}
//
//			final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
//					activePointerId);
//			final float x = MotionEventCompat.getX(ev, pointerIndex);
//			final float y = MotionEventCompat.getY(ev, pointerIndex);
//			final float xDiff = Math.abs(x - mLastMotionX);
//			final float yDiff = Math.abs(y - mLastMotionY);
//			float primaryDiff;
//			float secondaryDiff;
//
//			if (mOrientation == HORIZONTAL) {
//				primaryDiff = xDiff;
//				secondaryDiff = yDiff;
//			} else {
//				primaryDiff = yDiff;
//				secondaryDiff = xDiff;
//			}
//
//			if (DEBUG)
//				Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + ","
//						+ yDiff);
//
//			if (primaryDiff > mTouchSlop && primaryDiff > secondaryDiff) {
//				if (DEBUG)
//					Log.v(TAG, "Starting drag!");
//				mIsBeingDragged = true;
//				setScrollState(SCROLL_STATE_DRAGGING);
//				if (mOrientation == HORIZONTAL) {
//					mLastMotionX = x;
//				} else {
//					mLastMotionY = y;
//				}
//				setScrollingCacheEnabled(true);
//			} else {
//				if (secondaryDiff > mTouchSlop) {
//					// The finger has moved enough in the vertical
//					// direction to be counted as a drag... abort
//					// any attempt to drag horizontally, to work correctly
//					// with children that have scrolling containers.
//					if (DEBUG)
//						Log.v(TAG, "Starting unable to drag!");
//					mIsUnableToDrag = true;
//				}
//			}
//			break;
//		}
//
//		case MotionEvent.ACTION_DOWN: {
//			/*
//			 * Remember location of down touch. ACTION_DOWN always refers to
//			 * pointer index 0.
//			 */
//			if (mOrientation == HORIZONTAL) {
//				mLastMotionX = mInitialMotion = ev.getX();
//				mLastMotionY = ev.getY();
//			} else {
//				mLastMotionX = ev.getX();
//				mLastMotionY = mInitialMotion = ev.getY();
//			}
//			mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
//
//			if (mScrollState == SCROLL_STATE_SETTLING) {
//				// Let the user 'catch' the pager as it animates.
//				mIsBeingDragged = true;
//				mIsUnableToDrag = false;
//				setScrollState(SCROLL_STATE_DRAGGING);
//			} else {
//				completeScroll();
//				mIsBeingDragged = false;
//				mIsUnableToDrag = false;
//			}
//
//			if (DEBUG)
//				Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY
//						+ " mIsBeingDragged=" + mIsBeingDragged
//						+ "mIsUnableToDrag=" + mIsUnableToDrag);
//			break;
//		}
//
//		case MotionEventCompat.ACTION_POINTER_UP:
//			onSecondaryPointerUp(ev);
//			break;
//		}
//
//		/*
//		 * The only time we want to intercept motion events is if we are in the
//		 * drag mode.
//		 */
//		return mIsBeingDragged;
//	}
//
//	@Override
//	public boolean onTouchEvent(MotionEvent ev) {
//
//		if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
//			// Don't handle edge touches immediately -- they may actually belong
//			// to one of our
//			// descendants.
//			return false;
//		}
//
//		if (mAdapter == null || mAdapter.getCount() == 0) {
//			// Nothing to present or scroll; nothing to touch.
//			return false;
//		}
//
//		if (mVelocityTracker == null) {
//			mVelocityTracker = VelocityTracker.obtain();
//		}
//		mVelocityTracker.addMovement(ev);
//
//		final int action = ev.getAction();
//
//		switch (action & MotionEventCompat.ACTION_MASK) {
//		case MotionEvent.ACTION_DOWN: {
//			/*
//			 * If being flinged and user touches, stop the fling. isFinished
//			 * will be false if being flinged.
//			 */
//			completeScroll();
//
//			// Remember where the motion event started
//			if (mOrientation == HORIZONTAL) {
//				mLastMotionX = mInitialMotion = ev.getX();
//			} else {
//				mLastMotionY = mInitialMotion = ev.getY();
//			}
//			mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
//			break;
//		}
//		case MotionEvent.ACTION_MOVE:
//			if (!mIsBeingDragged) {
//				final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
//						mActivePointerId);
//				final float x = MotionEventCompat.getX(ev, pointerIndex);
//				final float y = MotionEventCompat.getY(ev, pointerIndex);
//				final float xDiff = Math.abs(x - mLastMotionX);
//				final float yDiff = Math.abs(y - mLastMotionY);
//				float primaryDiff;
//				float secondaryDiff;
//
//				if (mOrientation == HORIZONTAL) {
//					primaryDiff = xDiff;
//					secondaryDiff = yDiff;
//				} else {
//					primaryDiff = yDiff;
//					secondaryDiff = xDiff;
//				}
//
//				if (DEBUG)
//					Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff
//							+ "," + yDiff);
//				if (primaryDiff > mTouchSlop && primaryDiff > secondaryDiff) {
//					if (DEBUG)
//						Log.v(TAG, "Starting drag!");
//					mIsBeingDragged = true;
//					if (mOrientation == HORIZONTAL) {
//						mLastMotionX = x;
//					} else {
//						mLastMotionY = y;
//					}
//					setScrollState(SCROLL_STATE_DRAGGING);
//					setScrollingCacheEnabled(true);
//				}
//			}
//			if (mIsBeingDragged) {
//				// Scroll to follow the motion event
//				final int activePointerIndex = MotionEventCompat
//						.findPointerIndex(ev, mActivePointerId);
//				final float x = MotionEventCompat.getX(ev, activePointerIndex);
//				final float y = MotionEventCompat.getY(ev, activePointerIndex);
//
//				int size;
//				float scroll;
//
//				if (mOrientation == HORIZONTAL) {
//					size = getWidth();
//					scroll = getScrollX() + (mLastMotionX - x);
//					mLastMotionX = x;
//				} else {
//					size = getHeight();
//					scroll = getScrollY() + (mLastMotionY - y);
//					mLastMotionY = y;
//				}
//
//				final float lowerBound = Math.max(0, (mCurItem - 1) * size);
//				final float upperBound = Math.min(mCurItem + 1,
//						mAdapter.getCount() - 1)
//						* size;
//				if (scroll < lowerBound) {
//					scroll = lowerBound;
//				} else if (scroll > upperBound) {
//					scroll = upperBound;
//				}
//				if (mOrientation == HORIZONTAL) {
//					// Don't lose the rounded component
//					mLastMotionX += scroll - (int) scroll;
//					scrollTo((int) scroll, getScrollY());
//				} else {
//					// Don't lose the rounded component
//					mLastMotionY += scroll - (int) scroll;
//					scrollTo(getScrollX(), (int) scroll);
//				}
//				if (mOnPageChangeListener != null) {
//					final int position = (int) scroll / size;
//					final int positionOffsetPixels = (int) scroll % size;
//					final float positionOffset = (float) positionOffsetPixels
//							/ size;
//					mOnPageChangeListener.onPageScrolled(position,
//							positionOffset, positionOffsetPixels);
//				}
//			}
//			break;
//		case MotionEvent.ACTION_UP:
//			if (mIsBeingDragged) {
//				final VelocityTracker velocityTracker = mVelocityTracker;
//				velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
//				int initialVelocity;
//				float lastMotion;
//				int sizeOverThree;
//
//				if (mOrientation == HORIZONTAL) {
//					initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
//							velocityTracker, mActivePointerId);
//					lastMotion = mLastMotionX;
//					sizeOverThree = getWidth() / 3;
//				} else {
//					initialVelocity = (int) VelocityTrackerCompat.getYVelocity(
//							velocityTracker, mActivePointerId);
//					lastMotion = mLastMotionY;
//					sizeOverThree = getHeight() / 3;
//				}
//
//				mPopulatePending = true;
//				if ((Math.abs(initialVelocity) > mMinimumVelocity)
//						|| Math.abs(mInitialMotion - lastMotion) >= sizeOverThree) {
//					if (lastMotion > mInitialMotion) {
//						setCurrentItemInternal(mCurItem - 1, true, true);
//					} else {
//						setCurrentItemInternal(mCurItem + 1, true, true);
//					}
//				} else {
//					setCurrentItemInternal(mCurItem, true, true);
//				}
//
//				mActivePointerId = INVALID_POINTER;
//				endDrag();
//			}
//			break;
//		case MotionEvent.ACTION_CANCEL:
//			if (mIsBeingDragged) {
//				setCurrentItemInternal(mCurItem, true, true);
//				mActivePointerId = INVALID_POINTER;
//				endDrag();
//			}
//			break;
//		case MotionEventCompat.ACTION_POINTER_DOWN: {
//			final int index = MotionEventCompat.getActionIndex(ev);
//			if (mOrientation == HORIZONTAL) {
//				mLastMotionX = MotionEventCompat.getX(ev, index);
//			} else {
//				mLastMotionY = MotionEventCompat.getY(ev, index);
//			}
//			mActivePointerId = MotionEventCompat.getPointerId(ev, index);
//			break;
//		}
//		case MotionEventCompat.ACTION_POINTER_UP:
//			onSecondaryPointerUp(ev);
//			final int index = MotionEventCompat.findPointerIndex(ev,
//					mActivePointerId);
//			if (mOrientation == HORIZONTAL) {
//				mLastMotionX = MotionEventCompat.getX(ev, index);
//			} else {
//				mLastMotionY = MotionEventCompat.getY(ev, index);
//			}
//			break;
//		}
//		return true;
//	}
//
//	private void onSecondaryPointerUp(MotionEvent ev) {
//		final int pointerIndex = MotionEventCompat.getActionIndex(ev);
//		final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
//		if (pointerId == mActivePointerId) {
//			// This was our active pointer going up. Choose a new
//			// active pointer and adjust accordingly.
//			final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
//			if (mOrientation == HORIZONTAL) {
//				mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
//			} else {
//				mLastMotionY = MotionEventCompat.getY(ev, newPointerIndex);
//			}
//			mActivePointerId = MotionEventCompat.getPointerId(ev,
//					newPointerIndex);
//			if (mVelocityTracker != null) {
//				mVelocityTracker.clear();
//			}
//		}
//	}
//
//	private void endDrag() {
//		mIsBeingDragged = false;
//		mIsUnableToDrag = false;
//
//		if (mVelocityTracker != null) {
//			mVelocityTracker.recycle();
//			mVelocityTracker = null;
//		}
//	}
//
//	private void setScrollingCacheEnabled(boolean enabled) {
//		if (mScrollingCacheEnabled != enabled) {
//			mScrollingCacheEnabled = enabled;
//			if (USE_CACHE) {
//				final int size = getChildCount();
//				for (int i = 0; i < size; ++i) {
//					final View child = getChildAt(i);
//					if (child.getVisibility() != GONE) {
//						child.setDrawingCacheEnabled(enabled);
//					}
//				}
//			}
//		}
//	}
//
//	private class DataSetObserver implements
//			VerticalViewPagerCompat.DataSetObserver {
//		@Override
//		public void onDataSetChanged() {
//			dataSetChanged();
//		}
//	}
}
